"""
递归函数，一个函数在自己的函数体中调用自己
但是递归函数一定要有一个停下来的条件，不能一直调用下去
递归必须满足两个条件
有终止的条件（出口）
每一次调用都更接近于终止的条件

"""
#计算从 1 - n 的和

def sum_to_n(n):
    if n ==1:         #设置的出口
        return 1
    return n+sum_to_n(n-1)#nums = [2, 4, 6]

"""
sum_to_n(n)函数的运行逻辑基于递归思想，通过不断缩小问题规模来求解从 1 到 n 的累加和。我们以sum_to_n(3)为例，详细拆解其执行步骤：
调用sum_to_n(3)：
由于3 ≠ 1，执行return 3 + sum_to_n(2)，此时需要先计算sum_to_n(2)
进入sum_to_n(2)：
由于2 ≠ 1，执行return 2 + sum_to_n(1)，此时需要先计算sum_to_n(1)
进入sum_to_n(1)：
触发终止条件n == 1，直接返回1，不再继续调用自身
回溯计算：
sum_to_n(2)得到返回值：2 + 1 = 3
sum_to_n(3)得到返回值：3 + 3 = 6
最终结果为6（即 1+2+3 的和）。
整个过程像 "层层深入" 再 "层层返回" 的链条：
每一步递归都将问题sum_to_n(n)转化为更小的问题sum_to_n(n-1)
直到触达最小问题sum_to_n(1)（已知答案为 1）
再从最小问题的答案反向推导，得到原始问题的解
这种逻辑的核心是：把复杂问题拆解为同类的简单问题，直到简单到可以直接解决，再逆向合并结果。

"""


"""
编写一个递归函数 factorial(n)，用于计算并返回正整数 n 的阶乘（即 n! = n × (n−1) × … × 2 × 1）。
要求：
使用递归实现；
当 n <= 1 时，直接返回 1（这是递归的终止条件）；
不得使用循环（如 for 或 while）；
函数应能正确处理 n = 0（规定 0! = 1）。

"""
def factorial(n):
    if n <= 1:
        return 1
    return n * factorial(n - 1)
print(factorial(5))



"""

匿名函数：
py使用lambda来创建
所谓的匿名函数，就是不使用def这样的标准形式来定义函数
lambda的主体是一个表达式，而不是一个代码块，仅仅能在lambda表达式中封装有限的逻辑
只能写一个表达式不能写多行语句
自动的return的表达式结果
通常用于临时，简单的函数场景
lambda不是更快而是更简洁
"""

sum = lambda num1,num2,num3 : num1 + num2 + num3
print(sum(1,2,3))

def add(x,y):
    return x + y

add_lambda = lambda x,y : x + y
print(add(1,2))
print(add_lambda(1,2))

#匿名函数的精髓就是没有名字
print((lambda x:x*2)(5))

#作为参数来传递
#匿名函数＋内置函数一起使用（高阶函数）

num =[1,2,3,4]
squared = list(map(lambda x: x**2, num))
"""
map是高阶函数：主要作用是遍历元素，并且对元素调用func 在这里是lambda
"""
print(squared)


#字典的排序

salaries = {
    "aa":30000,
    "bb":20000,
    "cc":10000,

}
#按照薪资找最高者（返回key）
max_salary_person = max(salaries,key=lambda k: salaries[k])
print(max_salary_person)

def factorial(n):
    if n == 1:
        return 1
    return n * factorial(n - 1)


print(factorial(5))

words = ['apple', 'cat', 'dog', 'banana']
# 请补全下一行
long_words = filter(lambda w: len(w) > 3, words)
print(list(long_words))

scores = {'Alice': 88, 'Bob': 95, 'Charlie': 70}
sorted_names = sorted(scores, key=lambda x: scores[x])
print(sorted_names)


products = [
    {'name': '手机', 'price': 5000},
    {'name': '耳机', 'price': 300},
    {'name': '电脑', 'price': 8000}
]
products_max = max(products,key=lambda pro:pro['price'])['name']
print(products_max)

names = ['Alice', 'bob', 'Charlie', 'david']
names_plus = sorted(filter(lambda x: len(x) == 5, map(lambda s: s.lower(), names)))
print(names_plus)

"""
闭包函数
闭包= 内部函数+外部变量+外部函数返回内部函数
闭：内部函数
包：内部函数被外部引用（包裹了外部的变量）
闭包的三要素：
1.存在一个内部函数
2.内部函数引用了外部函数的变量
3.外部函数返回了内部函数

"""

def outer(x,y):      #外层函数 包含两个参数
    def inner():       #内层函数
        print(x+y)         #引用了外层函数的变量x y
    return inner

func =  outer(3,6)
func()

#普通函数传参
def add(a,b):
    return a+b
print(add(1,2))

#闭包
def mae_add(x,y):
    def adder():
        return x+y
    return adder
adder1=mae_add(1,2)
print(adder1())


#装饰器
"""
是一个特殊的闭包函数，用于给其他函数添加功能而不修改其源码
"""
def run(name):
    print("跑步")

def decorate(func):
    def new_func(name):
        print("========")
        print(f"我是{name}")
        print("========")
        func(name)    #调用原函数
    return new_func

#手动装饰
run1 = decorate(run)
run1("abc")




